//! # 认证集成示例
//!
//! 本示例展示了 rustcloud-gateway 和 rustcloud-auth 如何共同依赖 rustcloud-security 提供的基础功能，
//! 使用 trait 连接实现统一的认证授权体系。

use std::sync::Arc;
use std::collections::HashMap;
use axum::http::HeaderMap;

// 导入 rustcloud-security 的核心 trait
use rustcloud_security::prelude::*;

// 导入具体实现
use rustcloud_gateway::auth::{JwtAuthProvider, JwtConfig, ApiKeyAuthProvider};
use rustcloud_auth::service::{AuthService, AuthServiceConfig};
use rustcloud_auth::providers::AuthProviderRegistry;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 RustCloud 认证集成示例");
    println!("展示 rustcloud-gateway 和 rustcloud-auth 通过 rustcloud-security trait 连接");
    
    // 第一部分：rustcloud-gateway 的认证提供者（实现）
    println!("\n📦 第一部分：创建 rustcloud-gateway 认证提供者");
    
    // 1. 创建 JWT 认证提供者
    let jwt_config = JwtConfig {
        secret: "demo_secret_key".to_string(),
        ..Default::default()
    };
    let jwt_provider = JwtAuthProvider::new(jwt_config).await?;
    println!("✅ JWT 认证提供者已创建");
    
    // 2. 创建 API Key 认证提供者
    let api_key_provider = ApiKeyAuthProvider::new();
    println!("✅ API Key 认证提供者已创建");
    
    // 第二部分：展示 trait 统一性
    println!("\n🔗 第二部分：验证 rustcloud-security trait 统一性");
    
    // 将具体实现转换为 trait 对象
    let jwt_auth: Arc<dyn AuthProvider> = Arc::new(jwt_provider);
    let api_key_auth: Arc<dyn AuthProvider> = Arc::new(api_key_provider);
    
    println!("✅ JWT 提供者类型: {:?}", jwt_auth.provider_type());
    println!("✅ JWT 提供者名称: {}", jwt_auth.provider_name());
    println!("✅ API Key 提供者类型: {:?}", api_key_auth.provider_type());
    println!("✅ API Key 提供者名称: {}", api_key_auth.provider_name());
    
    // 第三部分：rustcloud-auth 高级服务
    println!("\n🏢 第三部分：rustcloud-auth 高级服务集成");
    
    // 1. 创建提供者注册表
    let mut registry = AuthProviderRegistry::new();
    registry.register("jwt".to_string(), Box::new(jwt_auth.clone()));
    registry.register("api_key".to_string(), Box::new(api_key_auth.clone()));
    
    // 2. 准备认证服务配置
    let auth_config = AuthServiceConfig {
        default_provider: "jwt".to_string(),
        permission_enabled: true,
        session_timeout: std::time::Duration::from_secs(3600),
        max_sessions_per_user: 5,
        enable_audit: false,
    };
    
    // 3. 创建权限检查器（使用新的统一实现）
    let permission_checker = Arc::new(PermissionCheckerFactory::create_default());
    
    // 4. 创建认证服务
    let mut providers_map = HashMap::new();
    providers_map.insert("jwt".to_string(), jwt_auth.clone());
    providers_map.insert("api_key".to_string(), api_key_auth.clone());
    
    let auth_service = AuthService::new(auth_config, providers_map, permission_checker);
    println!("✅ 认证服务已创建并集成了所有提供者");
    
    // 第四部分：实际认证流程演示
    println!("\n🔐 第四部分：实际认证流程演示");
    
    // 模拟 JWT 认证
    println!("\n--- JWT 认证演示 ---");
    let jwt_context = create_jwt_context()?;
    
    match auth_service.authenticate(&jwt_context).await {
        Ok(principal) => {
            println!("✅ JWT 认证成功: 用户 {}", principal.id);
            
            // 演示授权
            let resource = Resource::new(
                "user-service".to_string(),
                "/api/users".to_string(),
                "GET".to_string(),
            );
            
            match auth_service.authorize(&principal, &resource).await {
                Ok(authorized) => {
                    if authorized {
                        println!("✅ 授权成功: 允许访问 {}", resource.get_resource_id());
                    } else {
                        println!("❌ 授权失败: 拒绝访问 {}", resource.get_resource_id());
                    }
                }
                Err(e) => println!("❌ 授权检查失败: {}", e),
            }
        }
        Err(e) => println!("❌ JWT 认证失败: {}", e),
    }
    
    // 模拟 API Key 认证
    println!("\n--- API Key 认证演示 ---");
    let api_key_context = create_api_key_context();
    
    match auth_service.authenticate(&api_key_context).await {
        Ok(principal) => {
            println!("✅ API Key 认证成功: 用户 {}", principal.id);
        }
        Err(e) => println!("ℹ️  API Key 认证失败 (预期): {}", e),
    }
    
    // 第五部分：架构总结
    println!("\n📋 第五部分：架构总结");
    println!("🔹 rustcloud-security: 提供核心 trait 定义");
    println!("   - AuthProvider trait");
    println!("   - AuthorizationProvider trait"); 
    println!("   - AuthenticationService trait");
    println!("   - 核心数据结构 (Principal, Resource, AuthContext)");
    
    println!("🔹 rustcloud-gateway: 提供具体认证实现");
    println!("   - JwtAuthProvider 实现 AuthProvider + AuthorizationProvider");
    println!("   - ApiKeyAuthProvider 实现 AuthProvider + AuthorizationProvider");
    
    println!("🔹 rustcloud-auth: 提供高级服务封装");
    println!("   - AuthService 实现 AuthenticationService");
    println!("   - 集成多个认证提供者");
    println!("   - 提供企业级功能 (审计、会话管理、RBAC)");
    
    println!("\n✨ 这样的架构确保了：");
    println!("   ✅ 零重复: 认证逻辑不重复实现");
    println!("   ✅ 接口统一: 所有模块使用相同的 trait");
    println!("   ✅ 职责清晰: 每个模块专注自己的领域");
    println!("   ✅ 可扩展: 易于添加新的认证方式");
    
    Ok(())
}

// 使用新的统一权限检查器替代本地实现
// 原有的 DefaultPermissionChecker 已被移除，现在使用 rustcloud-core 中的实现
use rustcloud_core::auth::PermissionCheckerFactory;

// 创建权限检查器的方式从直接创建结构体改为使用工厂方法

/// 创建 JWT 认证上下文
fn create_jwt_context() -> Result<AuthContext, Box<dyn std::error::Error>> {
    // 这里我们创建一个模拟的 JWT 令牌上下文
    // 在实际应用中，这将是一个真实的 JWT 令牌
    let mut headers = HeaderMap::new();
    headers.insert("authorization", "Bearer mock.jwt.token".parse()?);
    
    Ok(AuthContext::new(
        headers,
        "GET".to_string(),
        "/api/users".to_string(),
        Some("127.0.0.1".to_string()),
    ))
}

/// 创建 API Key 认证上下文
fn create_api_key_context() -> AuthContext {
    let mut headers = HeaderMap::new();
    headers.insert("x-api-key", "sk_test_demo_key".parse().unwrap());
    
    AuthContext::new(
        headers,
        "GET".to_string(),
        "/api/data".to_string(),
        Some("127.0.0.1".to_string()),
    )
}